package com.sojson.util;

import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;

import com.sojson.constant.Constant;
import com.sojson.enums.core.EWeek;

/**
 * 日期工具类
 *
 * @author liu
 * @Date 2020-06-15 14:46:38
 * @Description
 *
 */
public class DateUtil extends org.apache.commons.lang3.time.DateUtils {

    public static final String[] PARSE_PATTERNS =
        {"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM", "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss",
            "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
    public static final String YYYY_MM_DD_HHFMMFSS_STR = "yyyy-MM-dd HH:mm:ss";
    public static final String YYYYIMMIDD_HHFMMFSS_STR = "yyyy/MM/dd HH:mm:ss";
    public static final String YYYYMMDD_HHMMSS_STR = "yyyyMMdd HHmmss";
    public static final String YYYYMMDDHHMMSS_STR = "yyyyMMddHHmmss";
    public static final String YYYY_MM_DD_STR = "yyyy-MM-dd";
    public static final String YYYYIMMIDD_STR = "yyyy/MM/dd";
    public static final String YYYYMMDD_STR = "yyyyMMdd";
    public static final String YYYYMM01_STR = "yyyyMM01";
    public static final String YYYY_MM_STR = "yyyy_MM";
    public static final String HHFMMFSS_STR = "HH:mm:ss";
    public static final String HHMMSS_STR = "HHmmss";

    public static final DateTimeFormatter YYYY_MM_DD_HHFMMFSS = DateTimeFormatter.ofPattern(YYYY_MM_DD_HHFMMFSS_STR);
    public static final DateTimeFormatter YYYYIMMIDD_HHFMMFSS = DateTimeFormatter.ofPattern(YYYYIMMIDD_HHFMMFSS_STR);
    public static final DateTimeFormatter YYYYMMDD_HHMMSS = DateTimeFormatter.ofPattern(YYYYMMDD_HHMMSS_STR);
    public static final DateTimeFormatter YYYYMMDDHHMMSS = DateTimeFormatter.ofPattern(YYYYMMDDHHMMSS_STR);
    public static final DateTimeFormatter YYYY_MM_DD = DateTimeFormatter.ofPattern(YYYY_MM_DD_STR);
    public static final DateTimeFormatter YYYYIMMIDD = DateTimeFormatter.ofPattern(YYYYIMMIDD_STR);
    public static final DateTimeFormatter YYYYMMDD = DateTimeFormatter.ofPattern(YYYYMMDD_STR);
    public static final DateTimeFormatter YYYYMM01 = DateTimeFormatter.ofPattern(YYYYMM01_STR);
    public static final DateTimeFormatter YYYY_MM = DateTimeFormatter.ofPattern(YYYY_MM_STR);
    public static final DateTimeFormatter HHFMMFSS = DateTimeFormatter.ofPattern(HHFMMFSS_STR);
    public static final DateTimeFormatter HHMMSS = DateTimeFormatter.ofPattern(HHMMSS_STR);

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static LocalDateTime nowLocalDateTime() {
        return LocalDateTime.now();
    }

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static LocalDate nowLocalDate() {
        return LocalDate.now();
    }

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static LocalTime nowLocalTime() {
        return LocalTime.now();
    }

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static Date nowDate() {
        return new Date();
    }

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static String nowString() {
        return nowString(YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static String nowString(DateTimeFormatter dateTimeFormatter) {
        return dateToString(LocalDateTime.now(), dateTimeFormatter);
    }

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static String nowString(String dateTimeFormatter) {
        return dateToString(LocalDateTime.now(), dateTimeFormatter);
    }

    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static long nowLong() {
        return System.currentTimeMillis();
    }

    /**
     * 将String字符串转换成LocalDateTime
     *
     * @param date 被转换的字符串
     * @return
     */
    public static LocalDateTime stringToLocalDateTime(String date) {
        return stringToLocalDateTime(date, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将String字符串转换成LocalDateTime
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static LocalDateTime stringToLocalDateTime(String date, DateTimeFormatter dateTimeFormatter) {
        return LocalDateTime.parse(date, dateTimeFormatter);
    }

    /**
     * 将String字符串转换成LocalDateTime
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static LocalDateTime stringToLocalDateTime(String date, String dateTimeFormatter) {
        return LocalDateTime.parse(date, DateTimeFormatter.ofPattern(dateTimeFormatter));
    }

    /**
     * 将String字符串转换成LocalDate
     *
     * @param date 被转换的字符串
     * @return
     */
    public static LocalDate stringToLocalDate(String date) {
        return stringToLocalDate(date, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将String字符串转换成LocalDate
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static LocalDate stringToLocalDate(String date, DateTimeFormatter dateTimeFormatter) {
        return LocalDate.parse(date, dateTimeFormatter);
    }

    /**
     * 将String字符串转换成LocalDate
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static LocalDate stringToLocalDate(String date, String dateTimeFormatter) {
        return LocalDate.parse(date, DateTimeFormatter.ofPattern(dateTimeFormatter));
    }

    /**
     * 将String字符串转换成LocalTime
     *
     * @param date 被转换的字符串
     * @return
     */
    public static LocalTime stringToLocalTime(String date) {
        return stringToLocalTime(date, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将String字符串转换成LocalTime
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static LocalTime stringToLocalTime(String date, DateTimeFormatter dateTimeFormatter) {
        return LocalTime.parse(date, dateTimeFormatter);
    }

    /**
     * 将String字符串转换成LocalTime
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static LocalTime stringToLocalTime(String date, String dateTimeFormatter) {
        return LocalTime.parse(date, DateTimeFormatter.ofPattern(dateTimeFormatter));
    }

    /**
     * 将String字符串转换成Date
     *
     * @param date 被转换的字符串
     * @return
     */
    public static Date stringToDate(String date) {
        return stringToDate(date, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将String字符串转换成Date
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static Date stringToDate(String date, DateTimeFormatter dateTimeFormatter) {
        return localDateTimeToDate(LocalDateTime.parse(date, dateTimeFormatter));
    }

    /**
     * 将String字符串转换成Date
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 字符串的格式
     * @return
     */
    public static Date stringToDate(String date, String dateTimeFormatter) {
        return localDateTimeToDate(LocalDateTime.parse(date, DateTimeFormatter.ofPattern(dateTimeFormatter)));
    }

    /**
     * 将String字符串转换成long类型时间戳
     *
     * @param date 被转换的字符串
     * @return 转换后的long类型时间戳
     * @throws ParseException
     */
    public static long stringToLong(String date) {
        return stringToLong(date, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将String字符串转换成long类型时间戳
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的long类型时间戳
     * @throws ParseException
     */
    public static long stringToLong(String date, DateTimeFormatter dateTimeFormatter) {
        return dateToLong(LocalDateTime.parse(date, dateTimeFormatter));
    }

    /**
     * 将String字符串转换成long类型时间戳
     *
     * @param date 被转换的字符串
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的long类型时间戳
     * @throws ParseException
     */
    public static long stringToLong(String date, String dateTimeFormatter) {
        return dateToLong(LocalDateTime.parse(date, DateTimeFormatter.ofPattern(dateTimeFormatter)));
    }

    /**
     * 将long类型时间戳转换成LocalDateTime
     *
     * @param date 被转换的long类型时间戳
     * @return
     */
    public static LocalDateTime longToLocalDateTime(long date) {
        return Instant.ofEpochMilli(date).atZone(ZoneOffset.ofHours(8)).toLocalDateTime();
    }

    /**
     * 将long类型时间戳转换成LocalDate
     *
     * @param date 被转换的long类型时间戳
     * @return
     */
    public static LocalDate longToLocalDate(long date) {
        return Instant.ofEpochMilli(date).atZone(ZoneOffset.ofHours(8)).toLocalDate();
    }

    /**
     * 将long类型时间戳转换成LocalTime
     *
     * @param date 被转换的long类型时间戳
     * @return
     */
    public static LocalTime longToLocalTime(long date) {
        return Instant.ofEpochMilli(date).atZone(ZoneOffset.ofHours(8)).toLocalTime();
    }

    /**
     * 将long类型时间戳转换成Date
     *
     * @param date 被转换的long类型时间戳
     * @return
     */
    public static Date longToDate(long date) {
        return new Date(date);
    }

    /**
     * 将long类型时间戳转换成String字符串
     *
     * @param date 被转换的long类型时间戳
     * @return 转换后的字符串---格式为:yyyy-MM-dd HH:mm:ss
     */
    public static String longToString(long date) {
        return longToString(date, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将long类型时间戳转换成String字符串
     *
     * @param date 被转换的long类型时间戳
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的字符串
     */
    public static String longToString(long date, DateTimeFormatter dateTimeFormatter) {
        return dateToString(longToLocalDateTime(date), dateTimeFormatter);
    }

    /**
     * 将long类型时间戳转换成String字符串
     *
     * @param date 被转换的long类型时间戳
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的字符串
     */
    public static String longToString(long date, String dateTimeFormatter) {
        return dateToString(longToLocalDateTime(date), dateTimeFormatter);
    }

    /**
     * 将LocalDateTime类型转换成String字符串
     *
     * @param LocalDateTime 被转换的时间
     * @return 转换后的字符串---格式为:yyyy-MM-dd HH:mm:ss
     */
    public static String dateToString(LocalDateTime localDateTime) {
        return dateToString(localDateTime, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将LocalDateTime类型转换成String字符串
     *
     * @param localDateTime 被转换的时间
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return
     */
    public static String dateToString(LocalDateTime localDateTime, DateTimeFormatter dateTimeFormatter) {
        return dateTimeFormatter.format(localDateTime);
    }

    /**
     * 将LocalDateTime类型转换成String字符串
     *
     * @param localDateTime 被转换的时间
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return
     */
    public static String dateToString(LocalDateTime localDateTime, String dateTimeFormatter) {
        return DateTimeFormatter.ofPattern(dateTimeFormatter).format(localDateTime);
    }

    /**
     * 将LocalDate类型转换成String字符串
     *
     * @param localDate 被转换的时间
     * @return 转换后的字符串---格式为:yyyy-MM-dd HH:mm:ss
     */
    public static String dateToString(LocalDate localDate) {
        return dateToString(localDate, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将LocalDate类型转换成String字符串
     *
     * @param localDate 被转换的时间
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return
     */
    public static String dateToString(LocalDate localDate, DateTimeFormatter dateTimeFormatter) {
        return dateTimeFormatter.format(localDate);
    }

    /**
     * 将LocalDate类型转换成String字符串
     *
     * @param localDate 被转换的时间
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return
     */
    public static String dateToString(LocalDate localDate, String dateTimeFormatter) {
        return DateTimeFormatter.ofPattern(dateTimeFormatter).format(localDate);
    }

    /**
     * 将LocalTime类型转换成String字符串
     *
     * @param LocalTime 被转换的时间
     * @return 转换后的字符串---格式为:yyyy-MM-dd HH:mm:ss
     */
    public static String dateToString(LocalTime localTime) {
        return dateToString(localTime, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将LocalTime类型转换成String字符串
     *
     * @param localTime 被转换的时间
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return
     */
    public static String dateToString(LocalTime localTime, DateTimeFormatter dateTimeFormatter) {
        return dateTimeFormatter.format(localTime);
    }

    /**
     * 将LocalTime类型转换成String字符串
     *
     * @param localTime 被转换的时间
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return
     */
    public static String dateToString(LocalTime localTime, String dateTimeFormatter) {
        return DateTimeFormatter.ofPattern(dateTimeFormatter).format(localTime);
    }

    /**
     * 将Date类型转换成String字符串
     *
     * @param date 被转换的时间
     * @return 转换后的字符串---格式为:yyyy-MM-dd HH:mm:ss
     */
    public static String dateToString(Date date) {
        return dateToString(date, YYYY_MM_DD_HHFMMFSS);
    }

    /**
     * 将Date类型转换成String字符串
     *
     * @param date 被转换的long类型时间戳
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的字符串
     */
    public static String dateToString(Date date, DateTimeFormatter dateTimeFormatter) {
        Instant instant = date.toInstant();
        ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
        LocalDateTime localDateTime = zdt.toLocalDateTime();
        return dateTimeFormatter.format(localDateTime);
    }

    /**
     * 将Date类型转换成String字符串
     *
     * @param date 被转换的long类型时间戳
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的字符串
     */
    public static String dateToString(Date date, String dateTimeFormatter) {
        Instant instant = date.toInstant();
        ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
        LocalDateTime localDateTime = zdt.toLocalDateTime();
        return DateTimeFormatter.ofPattern(dateTimeFormatter).format(localDateTime);
    }

    /**
     * 将Date类型格式化成Date类型
     *
     * @param date 被转换的时间
     * @return 转换后的Date---格式为:yyyy-MM-dd HH:mm:ss
     */
    public static Date dateToDate(Date date) {
        return stringToDate(dateToString(date, YYYY_MM_DD_HHFMMFSS));
    }

    /**
     * 将Date类型格式化成Date类型
     *
     * @param date 被转换的long类型时间戳
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的Date
     */
    public static Date dateToDate(Date date, DateTimeFormatter dateTimeFormatter) {
        return stringToDate(dateToString(date, dateTimeFormatter), dateTimeFormatter);
    }

    /**
     * 将Date类型格式化成Date类型
     *
     * @param date 被转换的long类型时间戳
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return 转换后的Date
     */
    public static Date dateToDate(Date date, String dateTimeFormatter) {
        return stringToDate(dateToString(date, dateTimeFormatter), dateTimeFormatter);
    }

    /**
     * 将LocalDateTime类型转换成时间戳
     *
     * @param localDateTime 被转换的时间
     * @param dateTimeFormatter 要转换成的字符串格式
     * @return
     */
    public static long dateToLong(LocalDateTime localDateTime) {
        return localDateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
    }

    /**
     * 将LocalDate类型转换成时间戳
     *
     * @param localDate 被转换的时间
     * @return
     */
    public static long dateToLong(LocalDate localDate) {
        return localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant().toEpochMilli();
    }

    /**
     * 将LocalTime类型转换成时间戳
     *
     * @param LocalTime 被转换的时间
     * @return
     */
    public static long dateToLong(LocalTime localTime) {
        // TODO
        return 0;
    }

    /**
     * 将Date类型转换成时间戳
     *
     * @param date 被转换的时间
     * @return
     */
    public static long dateToLong(Date date) {
        return date.getTime();
    }

    /**
     * 将Date类型转换成LocalDateTime
     *
     * @param date 被转换的时间
     * @return
     */
    public static LocalDateTime dateToLocalDateTime(Date date) {
        return getOffsetDateTime(date).toLocalDateTime();
    }

    /**
     * 将Date类型转换成LocalDateTime
     *
     * @param date 被转换的时间
     * @return
     */
    public static LocalDate dateToLocalDate(Date date) {
        return getOffsetDateTime(date).toLocalDate();
    }

    /**
     * 将Date类型转换成LocalDateTime
     *
     * @param date 被转换的时间
     * @return
     */
    public static LocalTime dateToLocalTime(Date date) {
        return getOffsetDateTime(date).toLocalTime();
    }

    /**
     * 从Date获取OffsetDateTime
     *
     * @param date
     */
    private static OffsetDateTime getOffsetDateTime(Date date) {
        return date.toInstant().atOffset(ZoneOffset.ofHours(8));
    }

    /**
     * 将Date类型转换成LocalDateTime
     *
     * @param date 被转换的时间
     * @return
     */
    public static Date localDateTimeToDate(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneOffset.ofHours(8)).toInstant());
    }

    /**
     * 将Date类型转换成LocalDate
     *
     * @param localDate 被转换的时间
     * @return
     */
    public static Date localDateTimeToDate(LocalDate localDate) {
        return Date.from(localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant());
    }

    /**
     * 将Date类型转换成LocalTime
     *
     * @param localTime 被转换的时间
     * @return
     */
    public static Date localDateTimeToDate(LocalTime localTime) {
        // TODO
        return Date.from(null);
    }

    /**
     * 将Date类型转换成LocalDateTime
     *
     * @param date 被转换的时间
     * @return
     */
    public static long localDateTimeToLong(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneOffset.ofHours(8)).toInstant()).getTime();
    }

    /**
     * 将Date类型转换成LocalDate
     *
     * @param localDate 被转换的时间
     * @return
     */
    public static long localDateTimeToLong(LocalDate localDate) {
        return Date.from(localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant()).getTime();
    }

    /**
     * 将Date类型转换成LocalTime
     *
     * @param localTime 被转换的时间
     * @return
     */
    public static Date localDateTimeToLong(LocalTime localTime) {
        // TODO
        return Date.from(null);
    }

    /**
     * 获取每月第一天0时0分0秒
     */
    public static Date getMonthOneDays() {
        return getMonthOneDays(nowDate());
    }

    /**
     * 获取每月第一天0时0分0秒
     * @return
     */
    public static Date getMonthOneDays(Date date) {
        LocalDateTime dateToLocalDateTime = dateToLocalDateTime(date);
        LocalDateTime with = dateToLocalDateTime.with(TemporalAdjusters.firstDayOfMonth()).withHour(0).withMinute(0)
            .withSecond(0).withNano(0);
        return localDateTimeToDate(with);
    }

    /**
     * 获取下一个月第一天0时0分0秒
     */
    public static Date getNextMonthOneDays() {
        return getMonthOneDays(nowDate());
    }

    /**
     * 获取下一个月第一天0时0分0秒
     * @return
     */
    public static Date getNextMonthOneDays(Date date) {
        LocalDateTime dateToLocalDateTime = dateToLocalDateTime(date);
        LocalDateTime with = dateToLocalDateTime.with(TemporalAdjusters.firstDayOfMonth()).withHour(0).withMinute(0)
            .withSecond(0).withNano(0).plusMonths(1);
        return localDateTimeToDate(with);
    }

    /**
     * 获取日期
     */
    public static Date getDate(int year, int month, int date) {
        return getDate(year, month, date, 0, 0, 0);
    }

    /**
     * 获取日期
     */
    public static Date getDate(int year, int month, int date, int hours, int minute, int second) {
        return getDate(year, month, date, hours, minute, second, 0);
    }

    /**
     * 获取日期
     */
    public static Date getDate(int year, int month, int date, int hours, int minute, int second, int millisecond) {
        LocalDateTime nowLocalDateTime = nowLocalDateTime();
        nowLocalDateTime = nowLocalDateTime.withYear(year).withMonth(month).withDayOfMonth(date).withHour(hours)
            .withMinute(minute).withSecond(second).withNano(millisecond * 1000000);
        return localDateTimeToDate(nowLocalDateTime);
    }

    /**
     * 获取年份
     * @return
     */
    public static int getYear() {
        return getYear(nowDate());
    }

    /**
     * 获取年份
     * @return
     */
    public static int getYear(Date date) {
        return getYear(dateToLocalDate(date));
    }

    /**
     * 获取年份
     * @return
     */
    public static int getYear(LocalDate date) {
        return date.getYear();
    }

    /**
     * 获取月份
     */
    public static int getMonth() {
        return getMonth(nowDate());
    }

    /**
     * 获取月份
     * @return
     */
    public static int getMonth(Date date) {
        return getMonth(dateToLocalDate(date));
    }

    /**
     * 获取月份
     */
    public static int getMonth(LocalDate date) {
        return date.getMonthValue();
    }

    /**
     * 获取日期
     */
    public static int getDate() {
        return getDate(nowDate());
    }

    /**
     * 获取日期
     */
    public static int getDate(Date date) {
        return getDate(dateToLocalDate(date));
    }

    /**
     * 获取日期
     */
    public static int getDate(LocalDate date) {
        return date.getDayOfMonth();
    }

    /**
     * 获取小时
     */
    public static void getHour(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 获取分钟
     */
    public static void getMinute(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 获取秒
     */
    public static void getSecond(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 设置年份
     */
    public static void setYear(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 设置月份
     */
    public static void setMonth(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 设置日期
     */
    public static void setDate(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 设置小时
     */
    public static void setHour(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 设置分钟
     */
    public static void setMinute(Date date) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 设置秒
     */
    public static void setSecond(Date date, int seconds) {
        // TODO
        new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate() {
        return new Date(ManagementFactory.getRuntimeMXBean().getStartTime());
    }

    /**
     * 日期型字符串转化为日期 格式
     */
    public static Date parseDate(Object str) {
        if (str == null) {
            return null;
        }
        try {
            return parseDate(str.toString(), PARSE_PATTERNS);
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * 计算两个时间差(天)
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return
     */
    public static long getDate(Date start, Date end) {
        long diff = end.getTime() - start.getTime();
        return diff / Constant.MILLIS_DAY;
    }

    /**
     * 计算两个时间差(时)
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return
     */
    public static long getHour(Date start, Date end) {
        long diff = end.getTime() - start.getTime();
        return diff / Constant.MILLIS_HOURS;
    }

    /**
     * 计算两个时间差(分)
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return
     */
    public static long getMinute(Date start, Date end) {
        long diff = end.getTime() - start.getTime();
        return diff / Constant.MILLIS_MINUTE;
    }

    /**
     * 计算两个时间差(秒)
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return
     */
    public static long getSecond(Date start, Date end) {
        long diff = end.getTime() - start.getTime();
        return diff / Constant.MILLIS_SECOND;
    }

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }

    /**
     * 获取星期
     *
     * @return
     */
    public static EWeek getWeek() {
        return getWeek(nowDate());
    }

    /**
     * 获取星期
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return
     */
    public static EWeek getWeek(Date date) {
        int val = dateToLocalDateTime(date).getDayOfWeek().getValue();
        if (val == EWeek.ONE.getCode()) {
            return EWeek.ONE;
        } else if (val == EWeek.TWO.getCode()) {
            return EWeek.TWO;
        } else if (val == EWeek.THREE.getCode()) {
            return EWeek.THREE;
        } else if (val == EWeek.FOUR.getCode()) {
            return EWeek.FOUR;
        } else if (val == EWeek.FIVE.getCode()) {
            return EWeek.FIVE;
        } else if (val == EWeek.SIX.getCode()) {
            return EWeek.SIX;
        } else if (val == EWeek.SEVEN.getCode()) {
            return EWeek.SEVEN;
        }
        return null;
    }

}